/**
 * 图片处理工具类
 */
let ctx = null
let canvasNode = null
/**
 * 获取图片的像素数据
 * @param {Object} bitmap - 图片对象 {path: string, width: number, height: number}
 * @param {Uint32Array} pixels - 用于存储像素数据的数组
 * @param {number} width - 要获取的宽度
 * @param {number} height - 要获取的高度
 * @returns {Promise<void>}
 */
export async function getImagePixels(bitmap, pixels, width, height) {
  return new Promise((resolve, reject) => {
    try {
      const query = wx.createSelectorQuery();
      query.select('#bitmapCanvas')
        .fields({
          node: true,
          size: true
        })
        .exec((res) => {
          const canvas = res[0].node;
          canvasNode = canvas; // 保存canvas节点供后续使用
          ctx = canvas.getContext('2d');

          // 获取原始图片尺寸
          const origWidth = width;
          const origHeight = height;

          // 设置 canvas 尺寸为旋转后的图片尺寸
          canvas.width = origWidth;
          canvas.height = origHeight;

          // 创建图片对象
          const img = canvas.createImage();
          img.src = bitmap.path;

          img.onload = async () => {
            try {
              // 清空画布
              ctx.clearRect(0, 0, origWidth, origHeight);
              ctx.drawImage(img, 0, 0, origWidth, origHeight);
              if (Array.isArray(pixels)) {
                // 获取像素数据
                const imageData = ctx.getImageData(0, 0, origWidth, origHeight);

                // 将RGBA数据转换为32位整数像素数据
                // 每个像素占用4个字节，依次为R、G、B和A
                // 将RGBA转换为ARGB格式
                for (let i = 0; i < imageData.data.length; i += 4) {
                  const r = imageData.data[i];
                  const g = imageData.data[i + 1];
                  const b = imageData.data[i + 2];
                  const a = imageData.data[i + 3];

                  // 转换为32位ARGB格式
                  pixels[i / 4] = (a << 24) | (r << 16) | (g << 8) | b;
                }
              }
              resolve();
            } catch (error) {
              reject(error);
            }
          };

          img.onerror = (error) => {
            reject(error);
          };
        });
    } catch (error) {
      reject(error);
    }
  });
}

/**
 * 微信小程序canvas保存图片
 * @param {Object} canvas - Canvas节点
 * @param {number} width - 宽度
 * @param {number} height - 高度
 * @returns {Promise<string>} 保存的临时路径
 */
function saveCanvasToImage(canvas, width, height) {
  return new Promise((resolve, reject) => {
    console.log('开始保存图片，宽高:', width, height);
    wx.canvasToTempFilePath({
      canvas: canvas, // 使用canvas节点而不是canvasId
      x: 0,
      y: 0,
      width: width,
      height: height,
      destWidth: width,
      destHeight: height,
      fileType: 'png',
      quality: 1,
      success: (res) => {
        console.log('图片生成成功:', res.tempFilePath);
        resolve(res.tempFilePath);
        saveImageToAlbum(res.tempFilePath);
      },
      fail: (error) => {
        console.error('保存图片失败:', error);
        reject(error);
      }
    });
  });
}

/**
 * 保存图片到相册
 * @param {string} tempFilePath - 临时文件路径
 * @returns {Promise<Object>} 结果
 */
function saveImageToAlbum(tempFilePath) {
  return new Promise((resolve, reject) => {
    wx.saveImageToPhotosAlbum({
      filePath: tempFilePath,
      success: function (res) {
        console.log('图片保存到相册成功:', res);
        wx.showToast({
          title: '图片已保存到相册',
          icon: 'success',
          duration: 2000
        });
        resolve(res);
      },
      fail: function (error) {
        console.error('图片保存到相册失败:', error);
        if (error.errMsg.indexOf('auth deny') >= 0) {
          wx.showModal({
            title: '提示',
            content: '需要您授权保存图片到相册',
            showCancel: false,
            success: () => {
              wx.openSetting({
                success(settingRes) {
                  console.log('设置结果', settingRes);
                }
              });
            }
          });
        } else {
          wx.showToast({
            title: '保存图片失败',
            icon: 'none',
            duration: 2000
          });
        }
        reject(error);
      }
    });
  });
}

/**
 * 将图片转换为打印机可用的点阵数据
 * @param {string} imagePath - 图片路径
 * @returns {Promise<{width: number, height: number, data: Uint8Array}>}
 */
export async function convertImageToBitmap(imagePath) {
  try {
    // 获取图片信息
    const imageInfo = await getImageInfo(imagePath);

    // 创建数据存储对象
    const bitmap = {
      path: imagePath,
      width: imageInfo.width,
      height: imageInfo.height
    };
    await getImagePixels(bitmap, null, bitmap.width, bitmap.height);


    return {
      width: bitmap.width,
      height: bitmap.height,
    };
  } catch (error) {
    console.error('转换图片失败:', error);
    throw error;
  }
}

/**
 * 获取图片信息
 * @param {string} imagePath - 图片路径
 * @returns {Promise<WechatMiniprogram.GetImageInfoSuccessCallbackResult>}
 */
function getImageInfo(imagePath) {
  return new Promise((resolve, reject) => {
    wx.getImageInfo({
      src: imagePath,
      success: resolve,
      fail: reject
    });
  });
}

export function getPixels(x, y, bWidth, remaining) {
  return new Promise((resolve) => {
    try {
      const imageData = ctx.getImageData(x, y, bWidth, remaining);
      // 获取像素数据
      // 这里的 imageData.data 是一个包含 RGBA 值的数组
      // 每个像素占用 4 个字节，依次为 R、G、B 和 A
      // 将 RGBA 转换为 ARGB 格式

      let pixels = [];
      for (let i = 0; i < imageData.data.length; i += 4) {
        let r = imageData.data[i];
        let g = imageData.data[i + 1];
        let b = imageData.data[i + 2];
        let a = imageData.data[i + 3];
        // 转成 int，和 Android ARGB 格式类似
        let color = (a << 24) | (r << 16) | (g << 8) | b;
        pixels.push(color);
      }
      resolve(pixels);
    } catch (error) {
      console.error('获取像素数据失败:', error);
      // 发生错误时返回空白数据（全白）
      let blankPixels = new Array(bWidth * remaining).fill(0xFFFFFFFF);
      resolve(blankPixels);
    }
  });
}


/**
 * 导出当前Canvas到相册
 * 可从组件或页面调用此方法保存当前图像
 * @returns {Promise<string>} 保存成功返回临时路径
 */
function exportCanvasToPhotoAlbum() {
  return new Promise((resolve, reject) => {
    if (!canvasNode || !ctx) {
      const error = new Error('Canvas未初始化或图像未绘制');
      console.error(error);
      wx.showToast({
        title: '暂无图像可保存',
        icon: 'none',
        duration: 2000
      });
      reject(error);
      return;
    }

    // 获取当前Canvas尺寸
    const width = canvasNode.width;
    const height = canvasNode.height;

    if (width <= 0 || height <= 0) {
      const error = new Error('Canvas尺寸无效');
      console.error(error);
      wx.showToast({
        title: '图像数据无效',
        icon: 'none',
        duration: 2000
      });
      reject(error);
      return;
    }

    console.log('开始导出图像到相册, 尺寸:', width, 'x', height);

    // 使用之前的保存函数
    saveCanvasToImage(canvasNode, width, height)
      .then(resolve)
      .catch(reject);
  });
}

export default {
  getImagePixels,
  convertImageToBitmap,
  getPixels,
  saveCanvasToImage,
  exportCanvasToPhotoAlbum
};